go 排序和交差并

2021-12-27 分类：GO 作者：admin 阅读（20）

基本类型排序(int、float64 和 string)

对于 int 、 float64 和 string 数组或是分片的排序， go 分别提供了 sort.Ints() 、 sort.Float64s() 和 sort.Strings() 函数，默认都是从小到大排序。

package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
    float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
    stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
   
    sort.Ints(intList)
    sort.Float64s(float8List)
    sort.Strings(stringList)
   
    fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
 
}

package main

import (

"fmt"

"sort"

)

func main() {

intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}

float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}

stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}

sort.Ints(intList)

sort.Float64s(float8List)

sort.Strings(stringList)

fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)

}

返回值：

[0 1 2 3 4 5 6 7 8 9]
[3.14 4.2 5.9 10 12.3 27.81828 31.4 50.4 99.9]
[a b c d f i w x y z]

[0 1 2 3 4 5 6 7 8 9]

[3.14 4.2 5.9 10 12.3 27.81828 31.4 50.4 99.9]

[a b c d f i w x y z]

2、降序排序

int 、 float64 和 string 都有默认的升序排序函数，现在问题是如果降序如何？有其他语言编程经验的人都知道，只需要交换 cmp 的比较法则就可以了， go 的实现是类似的，然而又有所不同。 go 中对某个 Type 的对象 obj 排序，可以使用 sort.Sort(obj) 即可，就是需要对 Type 类型绑定三个方法： Len() 求长度、Less(i,j) 比较第 i 和第 j 个元素大小的函数、 Swap(i,j) 交换第 i 和第 j 个元素的函数。sort 包下的三个类型 IntSlice 、 Float64Slice 、 StringSlice 分别实现了这三个方法，对应排序的是 [] int 、 [] float64 和 [] string 。如果期望逆序排序，只需要将对应的 Less 函数简单修改一下即可。

go 的 sort 包可以使用 sort.Reverse(slice) 来调换 slice.Interface.Less ，也就是比较函数，所以， int 、 float64 和 string 的逆序排序函数可以这么写：

package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
    float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
    stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
   
    sort.Sort(sort.Reverse(sort.IntSlice(intList)))
    sort.Sort(sort.Reverse(sort.Float64Slice(float8List)))
    sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
   
    fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
}

package main

import (

"fmt"

"sort"

)

func main() {

intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}

float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}

stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}

sort.Sort(sort.Reverse(sort.IntSlice(intList)))

sort.Sort(sort.Reverse(sort.Float64Slice(float8List)))

sort.Sort(sort.Reverse(sort.StringSlice(stringList)))

fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)

}

或者

   a:=[]int{3,7,9,4,5,6,2}
   // 正序1：
   sort.Ints(a)
   fmt.Println(a)
   // 正序2：
   sort.Slice(a, func(i, j int) bool {
      return a[i] < a[j]
   })
   fmt.Println(a)

   // 倒序1：
   sort.Sort(sort.Reverse(sort.IntSlice(a)))
   fmt.Println(a)
   // 倒序2：
   sort.Slice(a, func(i, j int) bool {
      return a[i] > a[j]
   })
   fmt.Println(a)

   var kArray = []string{"apt", "src", "fmt", "zoo", "amd", "yes"}
   // 正序1：
   sort.Strings(kArray)
   fmt.Println("正序：", kArray)
   // 正序2：
   sort.Slice(kArray, func(i, j int) bool {
      return kArray[i] < kArray[j]
   })
   fmt.Println("正序：", kArray)


   // 倒序1：
   sort.Slice(kArray, func(i, j int) bool {
      return kArray[i] > kArray[j]
   })
   fmt.Println("逆序：", kArray)
   // 倒序2：
   sort.Sort(sort.Reverse(sort.StringSlice(kArray)))
   fmt.Println("逆序：", kArray)

a:=[]int{3,7,9,4,5,6,2}

// 正序1：

sort.Ints(a)

fmt.Println(a)

// 正序2：

sort.Slice(a, func(i, j int) bool {

return a[i] < a[j]

})

fmt.Println(a)

// 倒序1：

sort.Sort(sort.Reverse(sort.IntSlice(a)))

fmt.Println(a)

// 倒序2：

sort.Slice(a, func(i, j int) bool {

return a[i] > a[j]

})

fmt.Println(a)

var kArray = []string{"apt", "src", "fmt", "zoo", "amd", "yes"}

// 正序1：

sort.Strings(kArray)

fmt.Println("正序：", kArray)

// 正序2：

sort.Slice(kArray, func(i, j int) bool {

return kArray[i] < kArray[j]

})

fmt.Println("正序：", kArray)

// 倒序1：

sort.Slice(kArray, func(i, j int) bool {

return kArray[i] > kArray[j]

})

fmt.Println("逆序：", kArray)

// 倒序2：

sort.Sort(sort.Reverse(sort.StringSlice(kArray)))

fmt.Println("逆序：", kArray)

结构体排序

package main
 
import (
	"fmt"
	"sort"
)
 
// 结构体定义
type test struct {
	value int
	str   string
}
 
func main() {
	s := make([]test, 5)
	s[0] = test{value: 2, str: "test2"}
	s[1] = test{value: 4, str: "test4"}
	s[2] = test{value: 1, str: "test1"}
	s[3] = test{value: 5, str: "test5"}
	s[4] = test{value: 3, str: "test3"}
	fmt.Println("初始化结果:")
	fmt.Println(s)
 
	// 从小到大排序(不稳定排序)
	sort.Slice(s, func(i, j int) bool {
		if s[i].value < s[j].value {
			return true
		}
		return false
	})
	fmt.Println("\n从小到大排序结果:")
	fmt.Println(s)
 
	// 从小到大排序(稳定排序)
	sort.SliceStable(s, func(i, j int) bool {
		if s[i].value < s[j].value {
			return true
		}
		return false
	})
 
	// 是否从小到大排序
	bLess := sort.SliceIsSorted(s, func(i, j int) bool {
		if s[i].value < s[j].value {
			return true
		}
		return false
	})
	fmt.Printf("数组s是否从小到大排序,bLess:%v\n", bLess)
 
	// 从大到小排序(不稳定排序)
	sort.Slice(s, func(i, j int) bool {
		if s[i].value > s[j].value {
			return true
		}
		return false
	})
	fmt.Println("\n从大到小排序结果:")
	fmt.Println(s)
 
	// 是否从大到小排序
	bMore := sort.SliceIsSorted(s, func(i, j int) bool {
		if s[i].value > s[j].value {
			return true
		}
		return false
	})
	fmt.Printf("数组s是否从大到小排序,bMore:%v\n", bMore)
}

package main

import (

"fmt"

"sort"

)

// 结构体定义

type test struct {

value int

str string

}

func main() {

s := make([]test, 5)

s[0] = test{value: 2, str: "test2"}

s[1] = test{value: 4, str: "test4"}

s[2] = test{value: 1, str: "test1"}

s[3] = test{value: 5, str: "test5"}

s[4] = test{value: 3, str: "test3"}

fmt.Println("初始化结果:")

fmt.Println(s)

// 从小到大排序(不稳定排序)

sort.Slice(s, func(i, j int) bool {

if s[i].value < s[j].value {

return true

}

return false

})

fmt.Println("\n从小到大排序结果:")

fmt.Println(s)

// 从小到大排序(稳定排序)

sort.SliceStable(s, func(i, j int) bool {

if s[i].value < s[j].value {

return true

}

return false

})

// 是否从小到大排序

bLess := sort.SliceIsSorted(s, func(i, j int) bool {

if s[i].value < s[j].value {

return true

}

return false

})

fmt.Printf("数组s是否从小到大排序,bLess:%v\n", bLess)

// 从大到小排序(不稳定排序)

sort.Slice(s, func(i, j int) bool {

if s[i].value > s[j].value {

return true

}

return false

})

fmt.Println("\n从大到小排序结果:")

fmt.Println(s)

// 是否从大到小排序

bMore := sort.SliceIsSorted(s, func(i, j int) bool {

if s[i].value > s[j].value {

return true

}

return false

})

fmt.Printf("数组s是否从大到小排序,bMore:%v\n", bMore)

}

稳定排序：排序前后两个相等的数相对位置不变，则算法稳定
非稳定排序：排序前后两个相等的数相对位置发生了变化，则算法不稳定

来源：https://blog.csdn.net/jfkidear/article/details/89279116

https://blog.csdn.net/abiao555/article/details/113238706

https://blog.csdn.net/yzf279533105/article/details/89459460

集合的分类:
并集：以属于A或属于B的元素为元素的集合成为A与B的并（集）
交集：以属于A且属于B的元素为元素的集合成为A与B的交（集）
差集：以属于A而不属于B的元素为元素的集合成为A与B的差（集）

package main
 
import "fmt"
 
//求并集
func union(slice1, slice2 []string) []string {
	m := make(map[string]int)
	for _, v := range slice1 {
		m[v]++
	}
 
	for _, v := range slice2 {
		times, _ := m[v]
		if times == 0 {
			slice1 = append(slice1, v)
		}
	}
	return slice1
}
 
//求交集
func intersect(slice1, slice2 []string) []string {
	m := make(map[string]int)
	nn := make([]string, 0)
	for _, v := range slice1 {
		m[v]++
	}
 
	for _, v := range slice2 {
		times, _ := m[v]
		if times == 1 {
			nn = append(nn, v)
		}
	}
	return nn
}
 
//求差集 slice1-并集
func difference(slice1, slice2 []string) []string {
	m := make(map[string]int)
	nn := make([]string, 0)
	inter := intersect(slice1, slice2)
	for _, v := range inter {
		m[v]++
	}
 
	for _, value := range slice1 {
		times, _ := m[value]
		if times == 0 {
			nn = append(nn, value)
		}
	}
	return nn
}
 
func main() {
	slice1 := []string{"1", "2", "3", "6", "8"}
	slice2 := []string{"2", "3", "5", "0"}
	un := union(slice1, slice2)
	fmt.Println("slice1与slice2的并集为：", un)
	in := intersect(slice1, slice2)
	fmt.Println("slice1与slice2的交集为：", in)
	di := difference(slice1, slice2)
	fmt.Println("slice1与slice2的差集为：", di)
}

package main

import "fmt"

//求并集

func union(slice1, slice2 []string) []string {

m := make(map[string]int)

for _, v := range slice1 {

m[v]++

}

for _, v := range slice2 {

times, _ := m[v]

if times == 0 {

slice1 = append(slice1, v)

}

return slice1

}

//求交集

func intersect(slice1, slice2 []string) []string {

m := make(map[string]int)

nn := make([]string, 0)

for _, v := range slice1 {

m[v]++

}

for _, v := range slice2 {

times, _ := m[v]

if times == 1 {

nn = append(nn, v)

}

return nn

}

//求差集 slice1-并集

func difference(slice1, slice2 []string) []string {

m := make(map[string]int)

nn := make([]string, 0)

inter := intersect(slice1, slice2)

for _, v := range inter {

m[v]++

}

for _, value := range slice1 {

times, _ := m[value]

if times == 0 {

nn = append(nn, value)

}

return nn

}

func main() {

slice1 := []string{"1", "2", "3", "6", "8"}

slice2 := []string{"2", "3", "5", "0"}

un := union(slice1, slice2)

fmt.Println("slice1与slice2的并集为：", un)

in := intersect(slice1, slice2)

fmt.Println("slice1与slice2的交集为：", in)

di := difference(slice1, slice2)

fmt.Println("slice1与slice2的差集为：", di)

}

来源：https://blog.csdn.net/yiweiyi329/article/details/101030510

该文章评论部分有热心网友对差集的异议，不过，该差集算法，仍然符合redis差集定义。

「三年博客，如果觉得我的文章对您有用，请帮助本站成长」

赞(0) 打赏

标签：

上一篇：mac brew 换源

下一篇：Go语言中 Print，Println 和 Printf 的区别

你可能感兴趣

golang for range 遍历

golang 参考题

使用 pprof 排查 Go 死锁的步骤

Golang工程师技术题

golang 简易打印请求服务端

go defer和recover

go 协程池

go 中的json.Marshal

golang 常用工具方法

golang 实现简易协程池

共有 0 - go 排序和交差并

点击这里取消回复。

博客简介

admin（6年前 (2020-03-09)）
分别用不同厚度的筏板定义，画图后这设置筏板变截面处理。 http://f.fwxgx.co...
评：新文章！
admin（6年前 (2020-03-09)）
分别用不同厚度的筏板定义，画图后这设置筏板变截面处理。 http://f.fwxgx.co...
评：新文章！
admin（6年前 (2020-03-09)）
新增一个框架图！ http://biji.jinli.vip/wp-content/upl...
评：新文章！
一位WordPress评论者（6年前 (2020-02-13)）
嗨，这是一条评论。要开始审核、编辑及删除评论，请访问仪表盘的“评论”页面。评论者头像来自...
评：世界，您好！

go 排序和交差并

基本类型排序(int、float64 和 string)

你可能感兴趣

共有 0 - go 排序和交差并

点击这里取消回复。

博客简介

最近更新

随机文章

热门标签

精彩评论